/**

 * jQuery.serialScroll

 * Copyright (c) 2007-2008 Ariel Flesler - aflesler(at)gmail(dot)com | http://flesler.blogspot.com

 * Dual licensed under MIT and GPL.

 * Date: 3/20/2008

 *

 * @projectDescription Animated scrolling of series.

 * @author Ariel Flesler

 * @version 1.2.1

 *

 * @id jQuery.serialScroll

 * @id jQuery.fn.serialScroll

 * @param {Object} settings Hash of settings, it is passed in to jQuery.ScrollTo, none is required.

 * @return {jQuery} Returns the same jQuery object, for chaining.

 *

 * http://flesler.blogspot.com/2008/02/jqueryserialscroll.html

 *

 * Notes:

 *	- The plugin requires jQuery.ScrollTo.

 *	- The hash of settings, is passed to jQuery.ScrollTo, so its settings can be used as well.

 */

;(function( $ ){



	var $serialScroll = $.serialScroll = function( settings ){

		$.scrollTo.window().serialScroll( settings );

	};



	//Many of these defaults, belong to jQuery.ScrollTo, check it's demo for an example of each option.

	//@see http://flesler.webs/jQuery.ScrollTo/

	$serialScroll.defaults = {//the defaults are public and can be overriden.

		duration:1000, //how long to animate.

		axis:'x', //which of top and left should be scrolled

		event:'click', //on which event to react.

		start:0, //first element (zero-based index)

		step:1, //how many elements to scroll on each action

		lock:true,//ignore events if already animating

		cycle:true, //cycle endlessly ( constant velocity )

		constant:true //use contant speed ?

		/*

		navigation:null,//if specified, it's a selector a collection of items to navigate the container

		target:null, //if specified, it's a selector to the element to be scrolled.

		interval:0, //it's the number of milliseconds to automatically go to the next

		lazy:false,//go find the elements each time (allows AJAX or JS content, or reordering)

		stop:false, //stop any previous animations to avoid queueing

		force:false,//force the scroll to the first element on start ?

		jump: false,//if true, when the event is triggered on an element, the pane scrolls to it

		items:null, //selector to the items (relative to the matched elements)

		prev:null, //selector to the 'prev' button

		next:null, //selector to the 'next' button

		onBefore: function(){}, //function called before scrolling, if it returns false, the event is ignored

		exclude:0 //exclude the last x elements, so we cannot scroll past the end

		*/

	};



	$.fn.serialScroll = function( settings ){

		settings = $.extend( {}, $serialScroll.defaults, settings );

		var event = settings.event, //this one is just to get shorter code when compressed

			step = settings.step, // idem

			lazy = settings.lazy;//idem



		return this.each(function(){

			var 

				context = settings.target ? this : document, //if a target is specified, then everything's relative to 'this'.

				$pane = $(settings.target || this, context),//the element to be scrolled (will carry all the events)

				pane = $pane[0], //will be reused, save it into a variable

				items = settings.items, //will hold a lazy list of elements

				active = settings.start, //active index

				auto = settings.interval, //boolean, do auto or not

				nav = settings.navigation, //save it now to make the code shorter

				timer; //holds the interval id



			if( !lazy )//if not lazy, go get the items now

				items = getItems();



			if( settings.force )

				jump( {}, active );//generate an initial call



			// Button binding, optionall

			$(settings.prev||[], context).bind( event, -step, move );

			$(settings.next||[], context).bind( event, step, move );



			// Custom events bound to the container

			if( !pane.ssbound )//don't bind more than once

				$pane

					.bind('prev.serialScroll', -step, move ) //you can trigger with just 'prev'

					.bind('next.serialScroll', step, move ) //for example: $(container).trigger('next');

					.bind('goto.serialScroll', jump ); //for example: $(container).trigger('goto', [4] );

			if( auto )

				$pane

					.bind('start.serialScroll', function(e){

						if( !auto ){

							clear();

							auto = true;

							next();

						}

					 })

					.bind('stop.serialScroll', function(){//stop a current animation

						clear();

						auto = false;

					});

			$pane.bind('notify.serialScroll', function(e, elem){//let serialScroll know that the index changed externally

				var i = index(elem);

				if( i > -1 )

					active = i;

			});

			pane.ssbound = true;//avoid many bindings



			if( settings.jump )//can't use jump if using lazy items and a non-bubbling event

				(lazy ? $pane : getItems()).bind( event, function( e ){

					jump( e, index(e.target) );

				});



			if( nav )

				nav = $(nav, context).bind(event, function( e ){

					e.data = Math.round(getItems().length / nav.length) * nav.index(this);

					jump( e, this );

				});



			function move( e ){

				e.data += active;

				jump( e, this );

			};

			function jump( e, button ){

				if( !isNaN(button) ){//initial or special call from the outside $(container).trigger('goto',[index]);

					e.data = button;

					button = pane;

				}



				var

					pos = e.data, n,

					real = e.type, //is a real event triggering ?

					$items = settings.exclude ? getItems().slice(0,-settings.exclude) : getItems(),//handle a possible exclude

					limit = $items.length,

					elem = $items[pos],

					duration = settings.duration;



				if( real )//real event object

					e.preventDefault();



				if( auto ){

					clear();//clear any possible automatic scrolling.

					timer = setTimeout( next, settings.interval ); 

				}



				if( !elem ){ //exceeded the limits

					n = pos < 0 ? 0 : limit - 1;

					if( active != n )//we exceeded for the first time

						pos = n;

					else if( !settings.cycle )//this is a bad case

						return;

					else

						pos = limit - n - 1;//invert, go to the other side

					elem = $items[pos];

				}



				if( !elem || real && active == pos || //could happen, save some CPU cycles in vain

					settings.lock && $pane.is(':animated') || //no animations while busy

					real && settings.onBefore && //callback returns false ?

					settings.onBefore.call(button, e, elem, $pane, getItems(), pos) === false ) return;



				if( settings.stop )

					$pane.queue('fx',[]).stop();//remove all its animations



				if( settings.constant )

					duration = Math.abs(duration/step * (active - pos ));//keep constant velocity



				$pane

					.scrollTo( elem, duration, settings )//do scroll

					.trigger('notify.serialScroll',[pos]);//in case serialScroll was called on this elem more than once.

			};

			function next(){//I'll use the namespace to avoid conflicts

				$pane.trigger('next.serialScroll');

			};

			function clear(){

				clearTimeout(timer);

			};

			function getItems(){

				return $( items, pane );

			};

			function index( elem ){

				if( !isNaN(elem) ) return elem;//number

				var $items = getItems(), i;

				while(( i = $items.index(elem)) == -1 && elem != pane )//see if it matches or one of its ancestors

					elem = elem.parentNode;

				return i;

			};

		});

	};



})( jQuery );